{
 "cells": [
  {
   "cell_type": "code",
   "id": "initial_id",
   "metadata": {
    "collapsed": true,
    "ExecuteTime": {
     "end_time": "2025-01-16T12:18:39.221278Z",
     "start_time": "2025-01-16T12:18:39.214872Z"
    }
   },
   "source": [
    "import matplotlib as mpl\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import sklearn\n",
    "import pandas as pd\n",
    "import os\n",
    "import sys\n",
    "import time\n",
    "from tqdm.auto import tqdm\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "\n",
    "print(sys.version_info)\n",
    "for module in mpl, np, pd, sklearn, torch:\n",
    "    print(module.__name__, module.__version__)\n",
    "\n",
    "device = torch.device(\"cuda:0\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "print(device)  #设备是cuda:0，即GPU，如果没有GPU则是cpu\n"
   ],
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sys.version_info(major=3, minor=12, micro=3, releaselevel='final', serial=0)\n",
      "matplotlib 3.10.0\n",
      "numpy 1.26.4\n",
      "pandas 2.2.3\n",
      "sklearn 1.6.0\n",
      "torch 2.5.1+cpu\n",
      "cpu\n"
     ]
    }
   ],
   "execution_count": 22
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 数据准备",
   "id": "1073bc64c567ba13"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-16T12:18:39.324191Z",
     "start_time": "2025-01-16T12:18:39.273838Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from torchvision import datasets\n",
    "from torchvision.transforms import ToTensor\n",
    "\n",
    "# 训练集\n",
    "train_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",\n",
    "    train=True,\n",
    "    download=True,\n",
    "    transform=ToTensor()\n",
    ")\n",
    "\n",
    "# 测试集\n",
    "test_ds = datasets.FashionMNIST(\n",
    "    root=\"data\",\n",
    "    train=False,\n",
    "    download=True,\n",
    "    transform=ToTensor()\n",
    ")\n",
    "\n",
    "# 从数据集到dataloader\n",
    "train_loader = torch.utils.data.DataLoader(train_ds, batch_size=32, shuffle=True)\n",
    "test_loader = torch.utils.data.DataLoader(test_ds, batch_size=32, shuffle=False)\n"
   ],
   "id": "55788f25672e1ebe",
   "outputs": [],
   "execution_count": 23
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 定义模型",
   "id": "b5e4f17ae389c008"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-16T12:18:39.333025Z",
     "start_time": "2025-01-16T12:18:39.328193Z"
    }
   },
   "cell_type": "code",
   "source": [
    "class NeuralNetwork(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        self.flatten = nn.Flatten()  # 展平层\n",
    "        self.linear_relu_stack = nn.Sequential(  # 线性层+激活层堆叠\n",
    "            nn.Linear(28 * 28, 300),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(300, 100),\n",
    "            nn.ReLU(),\n",
    "            nn.Linear(100, 10)\n",
    "        )\n",
    "\n",
    "    def forward(self, x):  # 前向传播\n",
    "        # 将输入数据 x 展平（Flatten），通常用于将多维数据转换为一维数据。\n",
    "        x = self.flatten(x)\n",
    "        # logits 是模型的原始输出，通常是未经过 Softmax 或 Sigmoid 处理的分数。\n",
    "        logits = self.linear_relu_stack(x)\n",
    "        return logits"
   ],
   "id": "d3016623476b4fd4",
   "outputs": [],
   "execution_count": 24
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 训练模型",
   "id": "8fb5dfcd77513c03"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-16T12:18:39.350937Z",
     "start_time": "2025-01-16T12:18:39.345029Z"
    }
   },
   "cell_type": "code",
   "source": [
    "from sklearn.metrics import accuracy_score\n",
    "\n",
    "\n",
    "@torch.no_grad()  # 装饰器，禁止梯度计算\n",
    "def evaluate(model, data_loader, loss_fct):\n",
    "    loss_list = []\n",
    "    pred_list = []\n",
    "    label_list = []\n",
    "    for datas, labels in data_loader:\n",
    "        datas = datas.to(device)\n",
    "        labels = labels.to(device)\n",
    "\n",
    "        # 前向传播\n",
    "        logits = model(datas)\n",
    "        loss = loss_fct(logits, labels)  # 验证集损失\n",
    "        # tensor.item() 获取tensor的数值，loss是只有一个元素的tensor\n",
    "        loss_list.append(loss.item())\n",
    "\n",
    "        # 预测\n",
    "        preds = logits.argmax(axis=-1)  # 预测类别\n",
    "        pred_list.extend(preds.cpu().numpy().tolist())  # tensor转numpy，再转list\n",
    "        label_list.extend(labels.cpu().numpy().tolist())\n",
    "\n",
    "    acc = accuracy_score(label_list, pred_list)  # 计算准确率\n",
    "    return np.mean(loss_list), acc  # # 返回验证集平均损失和准确率\n"
   ],
   "id": "24550945260b9755",
   "outputs": [],
   "execution_count": 25
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## Save Best Model",
   "id": "6fd06a23a5bccc23"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-16T12:18:39.367549Z",
     "start_time": "2025-01-16T12:18:39.361942Z"
    }
   },
   "cell_type": "code",
   "source": [
    "class SaveCheckpointsCallback:\n",
    "    def __init__(self, save_dir, save_step=500, save_best_only=True):\n",
    "        self.save_dir = save_dir  # 保存路径\n",
    "        self.save_step = save_step  # 保存步数\n",
    "        self.save_best_only = save_best_only  # 是否只保存最好的模型\n",
    "        self.best_metric = -1  # 最好的指标，指标不可能为负数，所以初始化为-1\n",
    "        # 创建保存路径\n",
    "        if not os.path.exists(self.save_dir):  # 如果不存在保存路径，则创建\n",
    "            os.makedirs(self.save_dir)\n",
    "\n",
    "    # 对象被调用时：当你将对象像函数一样调用时，Python 会自动调用 __call__ 方法。\n",
    "    # state_dict() 返回模型参数的字典，包括模型参数和优化器参数\n",
    "    # metric 是指标，可以是验证集的准确率，也可以是其他指标\n",
    "    def __call__(self, step, state_dict, metric=None):\n",
    "        if step % self.save_step > 0:\n",
    "            return  # 不是保存步数，则直接返回\n",
    "\n",
    "        if self.save_best_only:\n",
    "            assert metric is not None  # 必须传入metric\n",
    "            if metric >= self.best_metric:  # 如果当前指标大于最好的指标\n",
    "                # save checkpoint\n",
    "                # 保存最好的模型，覆盖之前的模型，不保存step，只保存state_dict，即模型参数，不保存优化器参数\n",
    "                torch.save(state_dict, os.path.join(self.save_dir, \"best.ckpt\"))\n",
    "                self.best_metric = metric  # 更新最好的指标\n",
    "        else:\n",
    "            # 保存模型\n",
    "            torch.save(state_dict, os.path.join(self.save_dir, f\"{step}.ckpt\"))\n",
    "            # 保存每个step的模型，不覆盖之前的模型，保存step，保存state_dict，即模型参数，不保存优化器参数\n"
   ],
   "id": "e93aec97aec45c4e",
   "outputs": [],
   "execution_count": 26
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## Early Stopping",
   "id": "3f9a004729448217"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-16T12:18:39.374609Z",
     "start_time": "2025-01-16T12:18:39.369554Z"
    }
   },
   "cell_type": "code",
   "source": [
    "class EarlyStopCallback:\n",
    "    def __init__(self, patience=5, min_delta=0.01):\n",
    "        self.patience = patience  # 多少个step没有提升就停止训练\n",
    "        self.min_delta = min_delta  # 最小的提升幅度\n",
    "        self.best_metric = -1  # 记录的最好的指标\n",
    "        self.counter = 0  # 计数器，记录连续多少个step没有提升\n",
    "\n",
    "    def __call__(self, metric):\n",
    "        if metric >= self.best_metric + self.min_delta:  # 如果指标提升了\n",
    "            self.best_metric = metric  # 更新最好的指标\n",
    "            self.counter = 0  # 计数器清零\n",
    "        else:\n",
    "            self.counter += 1  # 计数器加一\n",
    "\n",
    "    @property  # 使用@property装饰器，使得 对象.early_stop可以调用，不需要()\n",
    "    def early_stop(self):\n",
    "        # 如果计数器大于等于patience，则返回True，停止训练\n",
    "        return self.counter >= self.patience\n"
   ],
   "id": "d8fdc303a4d27c00",
   "outputs": [],
   "execution_count": 27
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 训练",
   "id": "b56dab87e8ff6485"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-16T12:18:39.386862Z",
     "start_time": "2025-01-16T12:18:39.378614Z"
    }
   },
   "cell_type": "code",
   "source": [
    "def training(model,\n",
    "             train_loader,\n",
    "             test_loader,\n",
    "             epoch,\n",
    "             loss_fct,\n",
    "             optimizer,\n",
    "             tensorboard_callback=None,\n",
    "             save_ckpt_callback=None,\n",
    "             early_stop_callback=None,\n",
    "             eval_step=500,\n",
    "             ):\n",
    "    record_dict = {\n",
    "        \"train\": [],\n",
    "        \"val\": []\n",
    "    }\n",
    "\n",
    "    global_step = 0  # 全局步数\n",
    "    model.train()  # 训练模式\n",
    "    with tqdm(total=epoch * len(train_loader)) as pbar:\n",
    "        for epoch_id in range(epoch):\n",
    "            for datas, labels in train_loader:\n",
    "                datas = datas.to(device)\n",
    "                labels = labels.to(device)\n",
    "\n",
    "                # 前向传播\n",
    "                logits = model(datas)\n",
    "                loss = loss_fct(logits, labels)  # 训练集损失\n",
    "                preds = logits.argmax(axis=-1)  # 预测类别\n",
    "\n",
    "                # 反向传播\n",
    "                optimizer.zero_grad()  # 梯度清零\n",
    "                loss.backward()  # 反向传播\n",
    "                optimizer.step()  # 优化器更新参数\n",
    "\n",
    "                # 计算准确率\n",
    "                acc = accuracy_score(labels.cpu().numpy(), preds.cpu().numpy())\n",
    "                loss = loss.cpu().item()\n",
    "\n",
    "                record_dict[\"train\"].append({\n",
    "                    \"loss\": loss,\n",
    "                    \"acc\": acc,\n",
    "                    \"step\": global_step\n",
    "                })\n",
    "\n",
    "                # 评估\n",
    "                if global_step % eval_step == 0:\n",
    "                    model.eval()  # 评估模式\n",
    "                    # 验证集损失和准确率\n",
    "                    val_loss, val_acc = evaluate(model, test_loader, loss_fct)\n",
    "                    record_dict[\"val\"].append({\n",
    "                        \"loss\": val_loss,\n",
    "                        \"acc\": val_acc,\n",
    "                        \"step\": global_step\n",
    "                    })\n",
    "                    model.train()  # 训练模式\n",
    "\n",
    "                    # 1. 使用 tensorboard 可视化\n",
    "                    if tensorboard_callback is not None:\n",
    "                        tensorboard_callback(\n",
    "                            global_step,\n",
    "                            loss=loss, val_loss=val_loss,\n",
    "                            acc=acc, val_acc=val_acc,\n",
    "                            lr=optimizer.param_groups[0][\"lr\"],  # 取出当前学习率\n",
    "                        )\n",
    "\n",
    "                    # 2. 保存模型权重 save model checkpoint\n",
    "                    if save_ckpt_callback is not None:\n",
    "                        # model.state_dict() 返回模型参数的字典，包括模型参数和优化器参数\n",
    "                        save_ckpt_callback(global_step, model.state_dict(), val_acc)\n",
    "                        # 保存最好的模型，覆盖之前的模型，保存step，保存state_dict,通过metric判断是否保存最好的模型\n",
    "\n",
    "                    # 3. 早停 early stopping\n",
    "                    if early_stop_callback is not None:\n",
    "                        # 验证集准确率不再提升，则停止训练\n",
    "                        early_stop_callback(val_acc)\n",
    "                        # 验证集准确率不再提升，则停止训练\n",
    "                        if early_stop_callback.early_stop:\n",
    "                            print(f\"Early stop at epoch {epoch_id} / global_step {global_step}\")\n",
    "                            return record_dict  # 早停，返回记录字典 record_dict\n",
    "\n",
    "                # 更新进度条和全局步数\n",
    "                pbar.update(1)  # 更新进度条\n",
    "                global_step += 1  # 全局步数加一\n",
    "                pbar.set_postfix({\"epoch\": epoch_id})\n",
    "\n",
    "    return record_dict  # 训练结束，返回记录字典 record_dict\n"
   ],
   "id": "2602ccd3cb633f69",
   "outputs": [],
   "execution_count": 28
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "",
   "id": "d111e077fd6e015"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-16T12:18:39.429083Z",
     "start_time": "2025-01-16T12:18:39.421874Z"
    }
   },
   "cell_type": "code",
   "source": [
    "epoch=100\n",
    "\n",
    "model = NeuralNetwork()\n",
    "\n",
    "# 1. 定义损失函数 采用MSE损失\n",
    "loss_fct = nn.CrossEntropyLoss()\n",
    "\n",
    "# 2. 定义优化器 采用SGD优化器\n",
    "optimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9)\n",
    "\n",
    "# 3.save model checkpoint\n",
    "save_ckpt_callback = SaveCheckpointsCallback(save_dir=\"checkpoints\", save_step=500, save_best_only=True)\n",
    "\n",
    "# 4. early stopping\n",
    "early_stop_callback = EarlyStopCallback(patience=10, min_delta=0.01)"
   ],
   "id": "8b42caff09582576",
   "outputs": [],
   "execution_count": 29
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-16T12:23:34.062066Z",
     "start_time": "2025-01-16T12:18:39.441088Z"
    }
   },
   "cell_type": "code",
   "source": [
    "model = model.to(device) # 将模型移到GPU上\n",
    "\n",
    "# 训练过程\n",
    "record_dict = training(\n",
    "    model,\n",
    "    train_loader,\n",
    "    test_loader,\n",
    "    epoch,\n",
    "    loss_fct,\n",
    "    optimizer,\n",
    "    tensorboard_callback=None,\n",
    "    save_ckpt_callback=save_ckpt_callback,\n",
    "    early_stop_callback=early_stop_callback,\n",
    "    eval_step=1000\n",
    ")"
   ],
   "id": "1b4d7f1cfe612c71",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "  0%|          | 0/187500 [00:00<?, ?it/s]"
      ],
      "application/vnd.jupyter.widget-view+json": {
       "version_major": 2,
       "version_minor": 0,
       "model_id": "f40c0bbf0bce4256b65d3bcc98c4a15e"
      }
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Early stop at epoch 21 / global_step 41000\n"
     ]
    }
   ],
   "execution_count": 30
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-16T12:23:34.292071Z",
     "start_time": "2025-01-16T12:23:34.063067Z"
    }
   },
   "cell_type": "code",
   "source": [
    "def plot_record_curves(record_dict, sample_step=1000):\n",
    "    # .set_index(\"step\") 将 step 列设置为 DataFrame 的索引\n",
    "    train_df = pd.DataFrame(record_dict[\"train\"]).set_index(\"step\").iloc[::sample_step]\n",
    "    val_df = pd.DataFrame(record_dict[\"val\"]).set_index(\"step\")\n",
    "\n",
    "    last_step = train_df.index[-1]  # 最后一步的步数\n",
    "\n",
    "    print(train_df)\n",
    "    print(val_df)\n",
    "\n",
    "    # 画图 \n",
    "    fig_num = len(train_df.columns)  # 画两张图,分别是损失和准确率\n",
    "\n",
    "    # plt.subplots：用于创建一个包含多个子图的图形窗口。\n",
    "    # 1：表示子图的行数为 1。\n",
    "    # fig_num：表示子图的列数，即子图的数量。\n",
    "    # figsize=(5 * fig_num, 5)：设置整个图形窗口的大小，宽度为 5 * fig_num，高度为 5。\n",
    "    # fig：返回的图形对象（Figure），用于操作整个图形窗口。\n",
    "    # axs：返回的子图对象（Axes 或 Axes 数组），用于操作每个子图。\n",
    "    fig, axs = plt.subplots(1, fig_num, figsize=(5 * fig_num, 5))\n",
    "    for idx, item in enumerate(train_df.columns):\n",
    "        # train_df.index 是 x 轴数据（通常是 step）。\n",
    "        # train_df[item] 是 y 轴数据（当前指标的值）。\n",
    "        axs[idx].plot(train_df.index, train_df[item], label=\"train:\" + item)\n",
    "        # val_df.index 是 x 轴数据。\n",
    "        # val_df[item] 是 y 轴数据。\n",
    "        axs[idx].plot(val_df.index, val_df[item], label=\"val:\" + item)\n",
    "        axs[idx].grid()  # 显示网格\n",
    "        axs[idx].legend()  # 显示图例\n",
    "        axs[idx].set_xticks(range(0, train_df.index[-1], 5000))  # 设置x轴刻度\n",
    "        axs[idx].set_xticklabels(map(lambda x: f\"{x // 1000}k\", range(0, last_step + 1, 5000)))  # 设置x轴标签\n",
    "        axs[idx].set_xlabel(\"step\")\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "\n",
    "plot_record_curves(record_dict)"
   ],
   "id": "de28437c6058f608",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "           loss      acc\n",
      "step                    \n",
      "0      2.324503  0.03125\n",
      "1000   0.915563  0.53125\n",
      "2000   0.528430  0.87500\n",
      "3000   0.361583  0.90625\n",
      "4000   0.532879  0.84375\n",
      "5000   0.414017  0.87500\n",
      "6000   0.412465  0.78125\n",
      "7000   0.482911  0.84375\n",
      "8000   0.161192  0.93750\n",
      "9000   0.545128  0.78125\n",
      "10000  0.282384  0.93750\n",
      "11000  0.241843  0.93750\n",
      "12000  0.294679  0.81250\n",
      "13000  0.440414  0.87500\n",
      "14000  0.250760  0.96875\n",
      "15000  0.333504  0.87500\n",
      "16000  0.388510  0.84375\n",
      "17000  0.375644  0.84375\n",
      "18000  0.309715  0.81250\n",
      "19000  0.378973  0.90625\n",
      "20000  0.357031  0.90625\n",
      "21000  0.257510  0.90625\n",
      "22000  0.162157  0.93750\n",
      "23000  0.393247  0.87500\n",
      "24000  0.376204  0.87500\n",
      "25000  0.360679  0.84375\n",
      "26000  0.174159  0.96875\n",
      "27000  0.343853  0.78125\n",
      "28000  0.239834  0.90625\n",
      "29000  0.180458  0.96875\n",
      "30000  0.256450  0.93750\n",
      "31000  0.240265  0.93750\n",
      "32000  0.404507  0.81250\n",
      "33000  0.143031  0.96875\n",
      "34000  0.216873  0.90625\n",
      "35000  0.306954  0.87500\n",
      "36000  0.200737  0.96875\n",
      "37000  0.336993  0.87500\n",
      "38000  0.199047  0.93750\n",
      "39000  0.143509  0.93750\n",
      "40000  0.347857  0.87500\n",
      "41000  0.324811  0.87500\n",
      "           loss     acc\n",
      "step                   \n",
      "0      2.303604  0.0934\n",
      "1000   0.815051  0.6937\n",
      "2000   0.654777  0.7641\n",
      "3000   0.577505  0.7982\n",
      "4000   0.537738  0.8124\n",
      "5000   0.531963  0.8060\n",
      "6000   0.490496  0.8244\n",
      "7000   0.480028  0.8275\n",
      "8000   0.470923  0.8350\n",
      "9000   0.483677  0.8235\n",
      "10000  0.453314  0.8404\n",
      "11000  0.443186  0.8425\n",
      "12000  0.462443  0.8325\n",
      "13000  0.449398  0.8399\n",
      "14000  0.432668  0.8474\n",
      "15000  0.418937  0.8494\n",
      "16000  0.435623  0.8470\n",
      "17000  0.414758  0.8524\n",
      "18000  0.407408  0.8550\n",
      "19000  0.398327  0.8568\n",
      "20000  0.405017  0.8554\n",
      "21000  0.398282  0.8599\n",
      "22000  0.387264  0.8633\n",
      "23000  0.386386  0.8631\n",
      "24000  0.384188  0.8648\n",
      "25000  0.387437  0.8617\n",
      "26000  0.378872  0.8645\n",
      "27000  0.380323  0.8651\n",
      "28000  0.379657  0.8665\n",
      "29000  0.380447  0.8659\n",
      "30000  0.377938  0.8663\n",
      "31000  0.367008  0.8702\n",
      "32000  0.368247  0.8685\n",
      "33000  0.365646  0.8696\n",
      "34000  0.358741  0.8721\n",
      "35000  0.377671  0.8634\n",
      "36000  0.354680  0.8718\n",
      "37000  0.350591  0.8752\n",
      "38000  0.349080  0.8763\n",
      "39000  0.352854  0.8739\n",
      "40000  0.355953  0.8713\n",
      "41000  0.371328  0.8657\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<Figure size 1000x500 with 2 Axes>"
      ],
      "image/png": "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"
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "execution_count": 31
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-16T12:24:01.345912Z",
     "start_time": "2025-01-16T12:24:01.340835Z"
    }
   },
   "cell_type": "code",
   "source": "record_dict[\"train\"][-5:]",
   "id": "775b113bb78383fa",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'loss': 0.3112372159957886, 'acc': 0.90625, 'step': 40996},\n",
       " {'loss': 0.3693093955516815, 'acc': 0.84375, 'step': 40997},\n",
       " {'loss': 0.10256384313106537, 'acc': 1.0, 'step': 40998},\n",
       " {'loss': 0.4125678539276123, 'acc': 0.90625, 'step': 40999},\n",
       " {'loss': 0.324810653924942, 'acc': 0.875, 'step': 41000}]"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 33
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-16T12:24:04.373004Z",
     "start_time": "2025-01-16T12:24:04.368122Z"
    }
   },
   "cell_type": "code",
   "source": "record_dict[\"val\"][-10:]",
   "id": "dbb21c010aaef95e",
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[{'loss': 0.3682469130038453, 'acc': 0.8685, 'step': 32000},\n",
       " {'loss': 0.36564600364135474, 'acc': 0.8696, 'step': 33000},\n",
       " {'loss': 0.35874146639634247, 'acc': 0.8721, 'step': 34000},\n",
       " {'loss': 0.3776714980435638, 'acc': 0.8634, 'step': 35000},\n",
       " {'loss': 0.35467978856100824, 'acc': 0.8718, 'step': 36000},\n",
       " {'loss': 0.35059071764254723, 'acc': 0.8752, 'step': 37000},\n",
       " {'loss': 0.34907974371799644, 'acc': 0.8763, 'step': 38000},\n",
       " {'loss': 0.35285363874782005, 'acc': 0.8739, 'step': 39000},\n",
       " {'loss': 0.3559530050919269, 'acc': 0.8713, 'step': 40000},\n",
       " {'loss': 0.3713278238313457, 'acc': 0.8657, 'step': 41000}]"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "execution_count": 34
  },
  {
   "metadata": {},
   "cell_type": "markdown",
   "source": "## 评估以及上线",
   "id": "1fa2f200745f7b63"
  },
  {
   "metadata": {},
   "cell_type": "code",
   "outputs": [],
   "execution_count": null,
   "source": [
    "model = NeuralNetwork() #上线时加载模型\n",
    "model = model.to(device) # 将模型移到GPU上"
   ],
   "id": "b106406c03208c15"
  },
  {
   "metadata": {
    "ExecuteTime": {
     "end_time": "2025-01-16T12:25:46.919752Z",
     "start_time": "2025-01-16T12:25:45.933703Z"
    }
   },
   "cell_type": "code",
   "source": [
    "# 加载最好的模型\n",
    "# torch.load：加载保存的模型权重或整个模型。\n",
    "# \"checkpoints/best.ckpt\"：模型权重文件路径。\n",
    "# weights_only=True：仅加载模型的权重，而不是整个模型（包括结构和参数）。这是 PyTorch 2.1 引入的新特性，用于增强安全性。\n",
    "# map_location=device：将模型加载到当前设备（GPU或CPU）。\n",
    "model.load_state_dict(torch.load(\"checkpoints/best.ckpt\",weights_only=True,map_location=device)) # 加载最好的模型\n",
    "\n",
    "model.eval()  # 评估模式\n",
    "loss,acc=evaluate(model,test_loader,loss_fct)\n",
    "print(f\"Test loss: {loss:.4f}, Test acc: {acc:.4f}\")"
   ],
   "id": "26cdacda63d5388e",
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test loss: 0.3491, Test acc: 0.8763\n"
     ]
    }
   ],
   "execution_count": 35
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
